package com.lt.lumentracks.task;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;

@Component
@Slf4j
public class DynamicScheduledTask {

    @Autowired
    private LastMsgFlushTask lastMsgFlushTask; // 业务任务类：刷新用户最后阅读消息
    @Autowired
    private HotPostRefreshTask hotPostRefreshTask; // 业务任务类：刷新热门帖子

    private TaskScheduler taskScheduler; // 任务调度器
    private ScheduledFuture<?> lastMsgScheduledFuture; // 最后消息刷新任务
    private ScheduledFuture<?> hotPostScheduledFuture; // 热门帖子刷新任务
    private static final int LAST_MSG_SECONDS = 5; // 最后消息刷新间隔
    private static final int HOT_POST_HOURS = 3; // 热门帖子刷新间隔（小时）

    // 初始化调度器
    @PostConstruct
    public void init() {
        taskScheduler = new ThreadPoolTaskScheduler(); // new 一个线程池调度器
        ((ThreadPoolTaskScheduler) taskScheduler).initialize(); // 初始化

        // 1.启动最后消息刷新任务（每5秒执行一次）
        lastMsgScheduledFuture = taskScheduler.scheduleAtFixedRate(
                lastMsgFlushTask::flush,
                Duration.ofSeconds(LAST_MSG_SECONDS)
        );
        
        // 2.启动热门帖子刷新任务（每3小时执行一次）
        hotPostScheduledFuture = taskScheduler.scheduleAtFixedRate(
                hotPostRefreshTask::refreshHotPosts,
                Duration.ofHours(HOT_POST_HOURS)
        );
        
        log.info("动态定时任务初始化完成：最后消息刷新任务({}秒)，热门帖子刷新任务({}小时)", 
                LAST_MSG_SECONDS, HOT_POST_HOURS);
    }


    // 取消最后消息刷新任务
    public Boolean cancelLastMsgTask() {
        if (lastMsgScheduledFuture != null && !lastMsgScheduledFuture.isCancelled()) {
            lastMsgScheduledFuture.cancel(false); // false 表示等待任务执行完毕再取消
            lastMsgFlushTask.setTaskStopped(true); // 通知业务任务类任务已停止
            log.warn("最后消息刷新任务已取消");
            return true;
        }else {
            return false;
        }
    }
    
    // 取消热门帖子刷新任务
    public Boolean cancelHotPostTask() {
        if (hotPostScheduledFuture != null && !hotPostScheduledFuture.isCancelled()) {
            hotPostScheduledFuture.cancel(false); // false 表示等待任务执行完毕再取消
            hotPostRefreshTask.setTaskStopped(true); // 通知业务任务类任务已停止
            log.warn("热门帖子刷新任务已取消");
            return true;
        }else {
            return false;
        }
    }
    
    // 取消所有任务
    public Boolean cancelTask() {
        boolean lastMsgCancelled = cancelLastMsgTask();
        boolean hotPostCancelled = cancelHotPostTask();
        return lastMsgCancelled || hotPostCancelled;
    }


    // 重启最后消息刷新任务
    public void restartLastMsgTask(Integer seconds) {
        cancelLastMsgTask();
        lastMsgScheduledFuture = taskScheduler.scheduleAtFixedRate(
                lastMsgFlushTask::flush,
                Duration.ofSeconds(seconds)
        );

        lastMsgFlushTask.setTaskStopped(false); // 通知业务任务类任务已重启
        log.info("最后消息刷新任务已重启，执行间隔为 {} 秒一次", seconds);
    }
    
    // 重启热门帖子刷新任务
    public void restartHotPostTask(Integer hours) {
        cancelHotPostTask();
        hotPostScheduledFuture = taskScheduler.scheduleAtFixedRate(
                hotPostRefreshTask::refreshHotPosts,
                Duration.ofHours(hours)
        );
//        // 使用Cron表达式，可以实现每天12点执行
//        hotPostScheduledFuture = taskScheduler.schedule(
//                hotPostRefreshTask::refreshHotPosts,
//                new CronTrigger("0 0 12 * * ?") // 每天中午12点
//        );

        hotPostRefreshTask.setTaskStopped(false); // 通知业务任务类任务已重启
        log.info("热门帖子刷新任务已重启，执行间隔为 {} 小时一次", hours);
    }
    
    // 重启所有任务（兼容原有方法）
    public void restartTask(Integer seconds) {
        restartLastMsgTask(seconds);
        restartHotPostTask(HOT_POST_HOURS); // 热门帖子任务使用默认间隔
    }
    // 方法重载
    public void restartTask() {
        restartLastMsgTask(LAST_MSG_SECONDS); // 默认任务间隔
        restartHotPostTask(HOT_POST_HOURS); // 热门帖子任务使用默认间隔
    }



    // 获取任务状态
    public Map<String, Object> getTaskStatus() {
        Map<String, Object> status = new HashMap<>();
        status.put("lastMsgTaskActive", lastMsgScheduledFuture != null && !lastMsgScheduledFuture.isCancelled());
        status.put("hotPostTaskActive", hotPostScheduledFuture != null && !hotPostScheduledFuture.isCancelled());
        status.put("lastMsgInterval", LAST_MSG_SECONDS);
        status.put("hotPostInterval", HOT_POST_HOURS);
        return status;
    }
    
    // 销毁时关闭调度器
    @PreDestroy
    public void destroy() {
        if (taskScheduler instanceof ThreadPoolTaskScheduler) {
            ((ThreadPoolTaskScheduler) taskScheduler).shutdown();
        }
    }

}
